from django.shortcuts import render, get_object_or_404
from django.shortcuts import redirect
from django.http import HttpResponse, response
from bson import json_util
from django.contrib.auth.decorators import login_required
from django.contrib.auth.decorators import permission_required
from bson.objectid import ObjectId

import datetime
import json
import pymongo
from userauth.models import UserInfo

# 引入相关的库数据库
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["test3"]
mycol_id = mydb["produceId"]        # 用于生成_id的数据库

# 为每份问卷生成ObjectId


def cgx_wenjuan_ObjectId():
    mycol_id.insert_one({"test": 1})

    for id in mycol_id.find({}, {'_id': 1}):
        _id = id['_id']

    mycol_id.delete_many({})

    return _id

# 转发问卷填写请求


@login_required
def pcpages(request, no):
    pcpages_url = 'pcpages/'+no+'/index.html'
    return render(request, pcpages_url)

# 问卷草稿箱请求转发


@login_required
def pcpages_cgx(request, no):
    # 根据no问卷类型，跳转至不同的页面中。
    return render(request, 'pcpages/'+no+'/index_cgx.html')


""" 
    no1-脑出血患者问卷
"""
Que1 = mydb["questionnaire1"]       # 存储脑出血患者调查问卷
QueCgx1 = mydb["questionnaire11"]   # 存储脑出血患者草稿箱调查问卷
# 提交问卷数据


def submitQue1(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx1.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx1.insert_one(Quedata)
        Que1.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx1(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人联系电话": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "姓名": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1, '填表人联系电话': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}
            wenjuans = QueCgx1.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx1.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que1.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx1.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人联系电话': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que1.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx1.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['填表人签名'],
                'name': wenjuan['姓名'],
                'phone': wenjuan['填表人联系电话'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue1(request, aid):
    if request.method == 'GET':
        for i in QueCgx1.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no1/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no1/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no1/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue1(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx1.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx1.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx1.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx1.insert_one(Quedata)
        Que1.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue1(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que1.delete_one({'_id': _id})
            QueCgx1.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no2-健康人群问卷
"""
Que2 = mydb["questionnaire2"]       # 存储健康人群调查问卷
QueCgx2 = mydb["questionnaire12"]   # 存储健康人群草稿箱调查问卷
# 提交问卷数据


def submitQue2(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx2.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx2.insert_one(Quedata)
        Que2.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx2(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人联系电话": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "姓名": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1, '填表人联系电话': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}
            wenjuans = QueCgx2.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx2.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que2.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx2.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人联系电话': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que2.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx2.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['填表人签名'],
                'name': wenjuan['姓名'],
                'phone': wenjuan['填表人联系电话'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue2(request, aid):
    if request.method == 'GET':
        for i in QueCgx2.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no2/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no2/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no2/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue2(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx2.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx2.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx2.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx2.insert_one(Quedata)
        Que2.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue2(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que2.delete_one({'_id': _id})
            QueCgx2.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no4-健康人群问卷(体检中心)
"""
Que4 = mydb["questionnaire4"]       # 存储健康人群调查问卷(体检中心)
QueCgx4 = mydb["questionnaire14"]   # 存储健康人群草稿箱调查问卷(体检中心)
# 提交问卷数据


def submitQue4(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx4.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx4.insert_one(Quedata)
        Que4.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx4(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人联系电话": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "姓名": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1, '填表人联系电话': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}
            wenjuans = QueCgx4.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx4.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que4.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx4.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人联系电话': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que4.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx4.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['填表人签名'],
                'name': wenjuan['姓名'],
                'phone': wenjuan['填表人联系电话'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue4(request, aid):
    if request.method == 'GET':
        for i in QueCgx4.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no4/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no4/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no4/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue4(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx4.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx4.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx4.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx4.insert_one(Quedata)
        Que4.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue4(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que4.delete_one({'_id': _id})
            QueCgx4.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no5-脑出血患者问卷(医院)
"""
Que5 = mydb["questionnaire5"]       # 存储脑出血患者调查问卷(医院)
QueCgx5 = mydb["questionnaire15"]   # 存储脑出血患者草稿箱调查问卷(医院)
# 提交问卷数据


def submitQue5(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx5.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx5.insert_one(Quedata)
        Que5.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx5(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人联系电话": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "姓名": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1, '填表人联系电话': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}
            wenjuans = QueCgx5.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx5.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que5.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx5.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人联系电话': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que5.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx5.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['填表人签名'],
                'name': wenjuan['姓名'],
                'phone': wenjuan['填表人联系电话'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue5(request, aid):
    if request.method == 'GET':
        for i in QueCgx5.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no5/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no5/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no5/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue5(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx5.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx5.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx5.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx5.insert_one(Quedata)
        Que5.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue5(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que5.delete_one({'_id': _id})
            QueCgx5.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no6-随访患者问卷
"""
Que6 = mydb["questionnaire6"]       # 存储随访问卷
QueCgx6 = mydb["questionnaire16"]   # 存储随访草稿箱问卷
# 提交问卷数据


def submitQue6(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx6.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx6.insert_one(Quedata)
        Que6.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx6(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人联系电话": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "姓名": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1, '填表人联系电话': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}
            wenjuans = QueCgx6.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx6.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que6.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx6.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人联系电话': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que6.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx6.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['填表人签名'],
                'name': wenjuan['姓名'],
                'phone': wenjuan['填表人联系电话'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue6(request, aid):
    if request.method == 'GET':
        for i in QueCgx6.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no6/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no6/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no6/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue6(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx6.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx6.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx6.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx6.insert_one(Quedata)
        Que6.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue6(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que6.delete_one({'_id': _id})
            QueCgx6.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no7-入户筛查表
"""
Que7 = mydb["questionnaire7"]       # 存储入户筛查表（湖南省）
QueCgx7 = mydb["questionnaire17"]   # 存储入户筛查表草稿箱（湖南省）
# 获取当前时间


def getDate():
    # 将日期转化为时间戳格式
    year = str(datetime.datetime.now().year)
    month = datetime.datetime.now().month
    if month < 10:
        month = '0' + str(month)
    else:
        month = str(month)
    day = datetime.datetime.now().day
    if day < 10:
        day = '0' + str(day)
    else:
        day = str(day)
    date = year + '-' + month + '-' + day
    return date
# 创建问卷对象


def createQue7(request):
    """
        注意，在创建时并不创建新的问卷ID，当且仅当该问卷存入数据库时，系统才会将登录账号与ID进行一次性写入。 
    """
    # 获取当前用户信息
    username = request.user.username  # 调查员账号
    searchname = request.user.name  # 调查员姓名
    phone = request.user.phone  # 调查员联系电话
    # 获取已填写问卷数量
    total = QueCgx7.find({"登录账号": username}, {}).count()
    # 获取当前时间
    date = getDate()
    # 存储创建好的问卷对象
    response_data = {}
    # 判断该账号是否第一次填写
    if total > 0:
        # 不是第一次填写，获取部分账号数据
        # 获取个人编号最大的问卷的信息(仅加载部分信息，不加载id等信息)
        recentQue = QueCgx7.find({"登录账号": username}, {"_id": 0, "填表人签名": 1, "填表人联系电话": 1, "个人编号": 1, "所在的省": 1, "所在的市": 1, "所在的乡镇或街道": 1,
                                                      "所在的村或社区": 1, "转送医院": 1, "转送时间": 1, "转送距离": 1, "调查员签名": 1,
                                                      "调查员联系电话": 1, "所在的县或区": 1}).sort("个人编号", -1).limit(1)
        recentQue_dict = recentQue.next()
        # 遍历个人编号最大的数据，
        for i, j in recentQue_dict.items():
            response_data[i] = j
            # 生成全新的_id
        # 更新个人编号及日期
        response_data['个人编号'] = recentQue_dict["个人编号"] + 1
        response_data['填表人填写日期'] = date
    else:
        # 第一次填写，返回初始信息

        # 进行赋值传送至前端
        response_data['填表人签名'] = searchname
        response_data['填表人联系电话'] = phone
        response_data['个人编号'] = 1
        response_data['填表人填写日期'] = date
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 提交问卷数据


def submitQue7(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx7.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx7.insert_one(Quedata)
        Que7.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx7(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人联系电话": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "姓名": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1, '填表人联系电话': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}
            wenjuans = QueCgx7.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx7.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que7.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx7.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人联系电话': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '姓名': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                # 问卷填写不完整，为了在操作状态栏显示编辑问卷or查看问卷
                """  
                    没有"是否需要再次编辑":"未填写完整":0
                    "是否需要再次编辑=是":"待提交":1
                    "是否需要再次编辑=否":待审核":2
                    "是否需要再次编辑=否 && 是否通过审核=是":"审核通过":3
                """
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que7.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '姓名' not in wenjuan.keys():
                    wenjuan['姓名'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx7.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['填表人签名'],
                'name': wenjuan['姓名'],
                'phone': wenjuan['填表人联系电话'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue7(request, aid):
    if request.method == 'GET':
        for i in QueCgx7.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no7/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no7/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no7/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue7(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx7.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx7.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx7.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx7.insert_one(Quedata)
        Que7.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue7(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que7.delete_one({'_id': _id})
            QueCgx7.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no8-健康人群问卷(湖南)
"""
Que8 = mydb["questionnaire8"]       # 存储健康人群问卷（湖南省）
QueCgx8 = mydb["questionnaire18"]   # 存储健康人群问卷草稿箱（湖南省）
# 提交问卷数据


def submitQue8(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx8.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx8.insert_one(Quedata)
        Que8.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx8(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "调查员签字": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '调查员签字': 1}
            wenjuans = QueCgx8.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx8.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que8.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '调查员签字' not in wenjuan.keys():
                    wenjuan['调查员签字'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx8.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '调查员签字': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que8.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '调查员签字' not in wenjuan.keys():
                    wenjuan['调查员签字'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx8.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['调查员签字'],
                'name': wenjuan['填表人签名'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue8(request, aid):
    if request.method == 'GET':
        for i in QueCgx8.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no8/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no8/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no8/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue8(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx8.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx8.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx8.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx8.insert_one(Quedata)
        Que8.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue8(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que8.delete_one({'_id': _id})
            QueCgx8.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no9-脑出血患者调查问卷(湖南)
"""
Que9 = mydb["questionnaire9"]       # 脑出血患者调查问卷（湖南省）
QueCgx9 = mydb["questionnaire19"]   # 脑出血患者调查问卷草稿箱（湖南省）
# 提交问卷数据


def submitQue9(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx9.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx9.insert_one(Quedata)
        Que9.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx9(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "调查员签字": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '调查员签字': 1}
            wenjuans = QueCgx9.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx9.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que9.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '调查员签字' not in wenjuan.keys():
                    wenjuan['调查员签字'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx9.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '调查员签字': 1,}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que9.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '调查员签字' not in wenjuan.keys():
                    wenjuan['调查员签字'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx9.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['调查员签字'],
                'name': wenjuan['填表人签名'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue9(request, aid):
    if request.method == 'GET':
        for i in QueCgx9.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no9/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no9/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no9/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue9(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx9.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx9.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx9.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx9.insert_one(Quedata)
        Que9.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue9(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que9.delete_one({'_id': _id})
            QueCgx9.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no10-脑梗塞患者调查问卷(湖南)
"""
Que10 = mydb["questionnaire10"]      # 存储脑梗塞患者调查问卷（湖南省）
QueCgx10 = mydb["questionnaire110"]  # 存储脑梗塞患者调查问卷草稿箱（湖南省）
# 提交问卷数据


def submitQue10(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx10.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx10.insert_one(Quedata)
        Que10.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx10(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "调查员签字": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1,
                       '填表人填写日期': 1, '是否需要再次编辑': 1, '调查员签字': 1}
            wenjuans = QueCgx10.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx10.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que10.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '调查员签字' not in wenjuan.keys():
                    wenjuan['调查员签字'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx10.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人填写日期': 1, '是否需要再次编辑': 1, '调查员签字': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que10.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '调查员签字' not in wenjuan.keys():
                    wenjuan['调查员签字'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx10.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['调查员签字'],
                'name': wenjuan['填表人签名'],
                'date': wenjuan['填表人填写日期'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue10(request, aid):
    if request.method == 'GET':
        for i in QueCgx10.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no10/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no10/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no10/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue10(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx10.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx10.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx10.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx10.insert_one(Quedata)
        Que10.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue10(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que10.delete_one({'_id': _id})
            QueCgx10.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))


""" 
    no11-街道乡镇级调查单位基本信息采集表(湖南)
"""
Que11 = mydb["questionnaire011"]     # 存储街道乡镇级调查单位基本信息采集表（湖南省）
QueCgx11 = mydb["questionnaire111"]  # 存储街道乡镇级调查单位基本信息采集表草稿箱（湖南省）
# 提交问卷数据


def submitQue11(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    Quedata['登录账号'] = request.user.username
    Quedata['_id'] = str(cgx_wenjuan_ObjectId())
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx11.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx11.insert_one(Quedata)
        Que11.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱数据请求处理


@login_required
def solveQueCgx11(request):
    if request.method == 'GET':
        # 获取前端提交上来的页数、每页的数据量以及查询内容
        pageNumber = request.GET.get('pageNumber')
        pageSize = request.GET.get('pageSize')
        searchText = request.GET.get('searchText', None)
        # 获取当前用户名
        username = request.user.username
        # 根据数据，计算分页后的对象切片
        if searchText:
            # 获取全部数据->处理->筛选->分页
            condition = [
                {"登录账号": username, "填表人签名": {"$regex": searchText}},
                {"登录账号": username, "填表人填写日期": {"$regex": searchText}},
                {"登录账号": username, "填表人联系电话": {"$regex": searchText}},
                {"登录账号": username, "街道/乡镇名称": {"$regex": searchText}},
            ]
            content = {'_id': 1, '填表人签名': 1, '填表人填写日期': 1,
                       '填表人联系电话': 1, '街道/乡镇名称': 1, '是否需要再次编辑': 1}
            wenjuans = QueCgx11.find({"$or": condition}, content).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            # 获取该用户总数据条数。
            total = QueCgx11.find({"$or": condition}, content).count()
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que11.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '街道/乡镇名称' not in wenjuan.keys():
                    wenjuan['街道/乡镇名称'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
        else:
            # 分页->处理
            # 获取该用户的目标问卷对象，并分页获取。
            wenjuans = QueCgx11.find({"登录账号": username}, {'_id': 1, '填表人签名': 1, '填表人填写日期': 1, '填表人联系电话': 1, '街道/乡镇名称': 1, '是否需要再次编辑': 1}).skip(
                (int(pageNumber) - 1) * int(pageSize)).limit(int(pageSize))
            """ 
                对初步分页出草稿箱数据进行处理主要有2类:
                1.有些问卷还没有到最后一页，因此没有"是否需要再次编辑"，但是判断是否能编辑也要依据这个字段，因此在这里创建.
                2.有些问卷还没有填写被调查员的姓名，这里进行赋值，对用户提示
            """
            # wenjuan_obj用于处理问卷对象
            wenjuan_obj = []
            for wenjuan in wenjuans:
                if '是否需要再次编辑' not in wenjuan.keys():
                    wenjuan['状态'] = 0
                else:
                    if wenjuan['是否需要再次编辑'] == '是':
                        wenjuan['状态'] = 1
                    if wenjuan['是否需要再次编辑'] == '否':
                        #到问卷数据库中找到这条问卷，判断是否通过审核
                        wj = Que11.find({"_id": wenjuan['_id']},{'审核是否通过':1}).next()
                        if '审核是否通过' not in wj.keys():
                            wenjuan['状态'] = 2
                        else:
                            wenjuan['状态'] = 3
                if '街道/乡镇名称' not in wenjuan.keys():
                    wenjuan['街道/乡镇名称'] = '尚未填写'
                wenjuan_obj.append(wenjuan)
            # 获取该用户总数据条数。
            total = QueCgx11.find({"登录账号": username}).count()

        # 记录每行的具体数据
        rows = []
        # 定义返回值data的格式
        data = {
            'total': total,
            'rows': rows
        }
        # 遍历问卷对象
        for wenjuan in wenjuan_obj:
            rows.append({
                'id': wenjuan['_id'],
                'searchName': wenjuan['填表人签名'],
                'address': wenjuan['街道/乡镇名称'],
                'date': wenjuan['填表人填写日期'],
                'phone': wenjuan['填表人联系电话'],
                'state': wenjuan['状态']
            })
        return HttpResponse(json.dumps(data), content_type='application/json')
# 问卷草稿箱编辑or查看


def editQue11(request, aid):
    if request.method == 'GET':
        for i in QueCgx11.find({"_id": aid}):
            surveyData = i
        if '是否需要再次编辑' not in surveyData.keys():
            # 编辑问卷
            return render(request, 'pcpages/no11/index_edit.html', {'surveyData': json.dumps(surveyData)})
        else:
            if surveyData['是否需要再次编辑'] == '是':  # 编辑问卷
                return render(request, 'pcpages/no11/index_edit.html', {'surveyData': json.dumps(surveyData)})
            if surveyData['是否需要再次编辑'] == '否':  # 查看问卷
                return render(request, 'pcpages/no11/index_view.html', {'surveyData': json.dumps(surveyData)})
# 问卷草稿箱修改并提交


def submitEditQue11(request):
    # 一份问卷有两个主键:登录账号和插入数据库中默认生成的_id
    Quedata = json.loads(request.body.decode('utf-8'))
    # 为问卷数据赋予ID和账号信息
    # 返回数据
    response_data = Quedata
    # 获取问卷与草稿箱数据库
    if Quedata['是否需要再次编辑'] == '是':
        QueCgx11.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx11.insert_one(Quedata)
    if Quedata['是否需要再次编辑'] == '否':
        QueCgx11.delete_one({"登录账号": Quedata['登录账号'], "_id": Quedata['_id']})
        QueCgx11.insert_one(Quedata)
        Que11.insert_one(Quedata)
    return HttpResponse(json.dumps(response_data), content_type="application/json")
# 问卷草稿箱删除


def deleteQue11(request):
    ret = {'status': True}
    try:
        # 获取需要的id数组
        queId = request.POST.getlist('queId[]')
        for _id in queId:
            Que11.delete_one({'_id': _id})
            QueCgx11.delete_one({'_id': _id})
    except Exception as e:
        ret['status'] = False
    return HttpResponse(json.dumps(ret))
